/*
FILE CONCAT ADD FILE
PATH: /ft/resources/client/CalendarPopup.js
*/

var CalendarPopup = function() {
	CalendarPopup.Super(this);
}

CalendarPopup.Extend(Popup);

CalendarPopup.prototype.CLASS_NAME_FOR_CALENDAR_POPUP = 'calendarPopup';

CalendarPopup.prototype.TITLE_TEXT = 'Create a Custom Timeframe';

CalendarPopup.prototype.drawPopup = function() {
	this.resetPopup();

	this.setTitleText(this.TITLE_TEXT);

	Element.create('div', {}, [
		Element.create('div', { 'className':'calendarHolder contain' }, [
			Element.create('div', { 'id':'calendarBegin', 'className':'calendarContainer' }),
			Element.create('div', { 'id':'calendarEnd', 'className':'calendarContainer' }),
		]),
		Element.create('div', { 'className':'applySettings' }, [
			Element.create('div', { 'id':'applyButton', 'className':'basicButton', 'style':'float:left' }, '<span>Apply Date Range</span>')
		])
	], this.getContent());

	this.draw();
	this.sizeShim();
};

CalendarPopup.prototype.getEventManagerForCalendarPopup = function() {
	var em = new EventManager();

	this.getEventManagerForCalendarPopup = function() {
		return em;
	}

	return this.getEventManagerForCalendarPopup();
}

CalendarPopup.prototype.init = function(oArgs) {
	oArgs = oArgs || {};

	if (!this.isVisible()) {
		this.drawPopup();

		this.getEventManagerForCalendarPopup().add(Element.get('applyButton'), 'click', this.setDateRange, this);

		var calendarBegin = Element.get('calendarBegin');
		var calendarEnd = Element.get('calendarEnd');

		var calendarLeft = new Calendar();
			if (oArgs.yearMinimum) {
				calendarLeft.setYearMinimum(oArgs.yearMinimum);
			}
			calendarLeft.draw(calendarBegin);

		var calendarRight = new Calendar();
			if (oArgs.yearMinimum) {
				calendarRight.setYearMinimum(oArgs.yearMinimum);
			}
			calendarRight.draw(calendarEnd);

		this.sizeShim();  // Needed by IE 6

		Element.addClass(Element.parseSelector('TD.today', Element.get('calendarHolder')), 'selected');
	}
}

CalendarPopup.prototype.resetPopup = function() {
	this.setTitleText('');
	this.clearContent();

	Element.addClass(this.getFrame(), this.CLASS_NAME_FOR_CALENDAR_POPUP);
}

CalendarPopup.prototype.setDateRange = function(ev, el, data) {
	if (ev) { ev.cancel(); }

	var startYear = Element.parseSelector('select.select-year', 'calendarBegin', 'first').value;
	var startMonth = Element.parseSelector('select.select-month', 'calendarBegin', 'first').value;
	var startDay = Element.parseSelector('td.selected', 'calendarBegin', 'first');
	if (startDay) {
		startDay = startDay.innerHTML;
	} else {
		alert('Please select a start day.');
		return;
	}

	var endYear = Element.parseSelector('select.select-year', 'calendarEnd', 'first').value;
	var endMonth = Element.parseSelector('select.select-month', 'calendarEnd', 'first').value;
	var endDay = Element.parseSelector('td.selected', 'calendarEnd', 'first');
	if (endDay) { 
		endDay = endDay.innerHTML;
	} else {
		alert('Select an end day.');
		return;
	}

	var startDate = new Date(startYear, startMonth, startDay);
	var startDateTime = startDate.getTime();

	var endDate = new Date(endYear, endMonth, endDay);
	var endDateTime = endDate.getTime();

	var today = new Date();
	var todayTime = today.getTime();

	if ((startDateTime > todayTime) || (endDateTime > todayTime)) {
		alert('Select both a start date and an end date that are both today or earlier.');
		return;
	}

	if (startDateTime > endDateTime) {
		alert('Select a start date that is earlier than the end date.');
		return;
	}

	this.getCallback()(startDate, endDate);  // returns a function that then will need to be called

	Element.addClass(this.getFrame(), 'wsodHidden');

	window.focus();
}

CalendarPopup.prototype.getCallback = function() {
	return function() {};
}

CalendarPopup.prototype.setCallback = function(passedFunction, context) {
	if (passedFunction) {
		context = context || window;

		this.getCallback = function() {
			return passedFunction.Context(context);
		}
	}
}

/*
FILE CONCAT ADD FILE
PATH: /ft/resources/client/chart/Calendar.js
*/
/*

Cleint Side Calendar Drawing Class

ToDo:

Add click events +(subscribable)
hide dates (dont allow dates to show after/before a given point)

*/

var Calendar = function(sDomId){

	//id to give Calendar Element
	this._DomId = sDomId || "Calendar";

	/*set dom calendar element*/
	//this._setCalendarElement();

	/*defaults*/
	this._currentDate = new Date();
	this.monthDisplay = "full";
	this.dayDisplay = "short"
	this.titleHeaderElement = "h2";
	this.monthHeaderElement = "h3";
	this.closeElement = "div";

	this._title = false;
	this._showClose = true;

}


/* ------------- Constants ------------------ */

Calendar.prototype.MONTH_LABELS =  [
	{ abbr: "Jan", num: "01", full: "January" },
	{ abbr: "Feb", num: "02", full: "February" },
	{ abbr: "Mar", num: "03", full: "March" },
	{ abbr: "Apr", num: "04", full: "April" },
	{ abbr: "May", num: "05", full: "May" },
	{ abbr: "Jun", num: "06", full: "June" },
	{ abbr: "Jul", num: "07", full: "July" },
	{ abbr: "Aug", num: "08", full: "August" },
	{ abbr: "Sep", num: "09", full: "September" },
	{ abbr: "Oct", num: "10", full: "October" },
	{ abbr: "Nov", num: "11", full: "November" },
	{ abbr: "Dec", num: "12", full: "December" }
	];

Calendar.prototype.DAYS = [

		{short:"S",abbr: "Sun",full:"Sunday"}
		,{short:"M",abbr: "Mon",full:"Monday"}
		,{short:"T",abbr: "Tue",full:"Tuesday"}
		,{short:"W",abbr: "Wed",full:"Wednesday"}
		,{short:"T",abbr: "Thur",full:"Thursday"}
		,{short:"F",abbr: "Fri",full:"Friday"}
		,{short:"S",abbr: "Sat",full:"Saturday"}

];

Calendar.prototype.YEAR_DEFAULT = '1984';

Calendar.prototype.CSS_CLASS_NAME = "calendar";

/* ------------- Configurable ------------------ */


Calendar.prototype.setMonthDisplay = function(sDisplayType) {

	this.monthDisplay = sDisplayType || this.monthDisplay;

}

Calendar.prototype.setDayDisplay = function(sDisplayType) {

	this.dayDisplay = sDisplayType || this.dayDisplay;

}

Calendar.prototype.setYearMinimum = function(year) {
	if (!year) {
		return;
	}

	this.getYearMinimum = function() {
		return Number(year);
	}

	return this.getYearMinimum();
}

Calendar.prototype.getYearMinimum = function() {
	return Number(this.YEAR_DEFAULT);
}

Calendar.prototype.subscribeSelectHandler = function(handler,context, data){

	this._customHandler = {

		handler:handler
		,context:context
		,data:data

	}

}

Calendar.prototype.setTitle = function(sTitleText){

	if(sTitleText){

		this._title = sTitleText;

	}

}

Calendar.prototype.disableCloseDisplay = function(bDisable) {

	this._showClose = !bDisable;

}

/* ------------- Public Methods ------------------ */

Calendar.prototype.draw = function(oContainer) {

	if(oContainer) {

		this.setContainer(oContainer);

	}

	this._setCalendarElement();

	//this._drawCloseElement();

	this._drawTitle();

	this._drawMonthLabel();

	//this._drawIncrementButtons();

	this._drawCalendarTable();

}



Calendar.prototype.getSelectedDate = function(){

	return this.selectedDate || false;

}

Calendar.prototype.incrementMonth = function(){

	var oNewDate = new Date(this._currentDate.getFullYear(),this._currentDate.getMonth()+2,0);

	this._setCalendarElement();

	this._setCurrentDate(oNewDate);

	this.draw();

}

Calendar.prototype.decrementMonth = function(){

	var oNewDate = new Date(this._currentDate.getFullYear(),this._currentDate.getMonth(),0);

	this._setCalendarElement();

	this._setCurrentDate(oNewDate);

	this.draw();

}

Calendar.prototype.selectDay = function(event,el,data) {

	//remove current selected
	var rSelected = Element.parseSelector("TD.selected",this.CalendarElement);

	if(rSelected && rSelected.length){

		Element.removeClass(rSelected,"selected");

	}

	//add selected class

	Element.addClass(el,"selected");

	//save selected date
	this._setSelectedDate(data.date);

	//for updating month display
	this._setCurrentDate(data.date);

	//highlight dates w/in range of selected && highlight point
	this.draw();

	//fire custom user event
	this._fireCustomSelectHandler(event,el);

}

Calendar.prototype.setContainer = function(oContainer){

	var oContainer = Element.get(oContainer);

	this._containerElement = oContainer;

}

Calendar.prototype.setSelectedDay = function(oDate){

	this._setSelectedDate(oDate);

	this._setCurrentDate(oDate);

}

//oRange = {from:oDate,to:oDate}
Calendar.prototype.addDisabledDateRange = function(oRange) {

	this._disabledRanges = this._disabledRanges || [];

	//default to/from dates if none provided
	oRange.to = oRange.to || new Date(9999,1,1);

	oRange.from = oRange.from || new Date(1,1,1);

	this._disabledRanges.push(oRange);

}

Calendar.prototype.close = function(){

	Element.remove(this.CalendarElement);

}

//add .highlight to dates between this date and selected date
Calendar.prototype.setHighlightPoint = function(oDate){

	this._highlightPoint = oDate;

}

/* ------------- Private Methods ------------------ */

Calendar.prototype._fireCustomSelectHandler = function(event,el){

	if(this._customHandler) {

		if(this._customHandler.context) {

			this._customHandler.handler.call(this._customHandler.context,event,el,this._customHandler.data)

		} else {

			this._customHandler.handler(event,el,this._customHandler.data);

		}

	}

}

Calendar.prototype._setCurrentDate = function(oDate){

	this._currentDate = oDate;

}

Calendar.prototype._setSelectedDate = function(oDate){

	this.selectedDate = oDate;

}


Calendar.prototype._getFirstDayOfMonth = function(){

	return new Date(this._currentDate.getFullYear(),this._currentDate.getMonth(),1).getDay();

}

Calendar.prototype._getDaysInMonth = function() {

	var iYear = this._currentDate.getFullYear();

	var iMonth = this._currentDate.getMonth();

	var oDate = new Date(iYear, iMonth+1, 0);

	return oDate.getDate();

}

Calendar.prototype._setCalendarElement = function(){

	var oParentElement = this._containerElement || document.body;

	if(this.CalendarElement && this.CalendarElement.parentNode) {

			Element.remove(this.CalendarElement);

	}

	if(this._DomId) {

			this.CalendarElement = Element.create("div",{className:this.CSS_CLASS_NAME,id:this._DomId},null,oParentElement);

	} else {

		this.CalendarElement = Element.create("div",{className:this.CSS_CLASS_NAME},null,oParentElement);

	}

}

//store/reset date info for current element being drawn
Calendar.prototype._setDayDrawing = function(iDay){

	var oDayDrawing = {};

	var oDate = new Date(this._currentDate.getFullYear(),this._currentDate.getMonth(),iDay);

	oDayDrawing.Date = oDate;

	oDayDrawing.year = oDate.getFullYear();

	oDayDrawing.month = oDate.getMonth();

	oDayDrawing.day = oDate.getDate();

	this._dayDrawing = oDayDrawing;

}

Calendar.prototype._checkDayIsToday = function(){

	var oNow = new Date();

	if(oNow.getFullYear() != this._dayDrawing.year) {

		return false;

	}

	if(oNow.getMonth() != this._dayDrawing.month) {

		return false;

	}

	if(oNow.getDate() == this._dayDrawing.day) {

		return true;

	}

	return false;

}

Calendar.prototype._checkIsWeekend = function(iDay){
	var oDate = new Date(this._dayDrawing.Date.getFullYear(),this._dayDrawing.Date.getMonth(),this._dayDrawing.Date.getDate());
	
	if (oDate.getDay() == 0 || oDate.getDay() == 6) {
		return true;
	} else {
		return false;
	}
}

Calendar.prototype._checkIsSelected = function(){

	if(!this.selectedDate) {

		return false;

	}

	if(this.selectedDate.getFullYear() != this._dayDrawing.year){

		return false;

	}

	if(this.selectedDate.getMonth() != this._dayDrawing.month){

		return false;

	}

	if(this.selectedDate.getDate() == this._dayDrawing.day) {

		return true;

	}

	return false;

}

Calendar.prototype._checkIsDisabled = function(){

	if(!this._disabledRanges) {

		return false;

	}

	for(var i=0;i<this._disabledRanges.length;i++) {

		var oRange = this._disabledRanges[i];

		if(this._dayDrawing.Date >= oRange.from && this._dayDrawing.Date <= oRange.to) {

			return true

		}

	}

	return false;

}

Calendar.prototype._checkIsHighlightPoint = function(){

	if(!this._highlightPoint){

		return false;

	}

	if(this._highlightPoint.getFullYear() != this._dayDrawing.year) {

		return false;

	}

	if(this._highlightPoint.getMonth() != this._dayDrawing.month) {

		return false

	}

	if(this._highlightPoint.getDate() == this._dayDrawing.day) {

		return true;

	}

	return false;

}

Calendar.prototype._checkIsHighlighted = function(){

	if(this._highlightPoint && this.selectedDate) {

		var oDate = this._dayDrawing.Date;

		var bIsBetween = (oDate > this._highlightPoint && oDate < this.selectedDate) || (oDate < this._highlightPoint && oDate > this.selectedDate);

		return bIsBetween;

	}

	return false;

}

Calendar.prototype._getDateClass = function(iDay){

	var rClassNames = ["date"];

	if(this._checkIsHighlightPoint()){

		rClassNames.push("highlightPoint");

	}

	if(this._checkDayIsToday()){

		rClassNames.push("today");

	}

	if(this._checkIsSelected()) {

		rClassNames.push("selected");

	}

	if(this._checkIsDisabled()) {

		rClassNames.push("disabled");

	}

	if(this._checkIsHighlighted()) {

		rClassNames.push("highlight");

	}

	if(!this._dayDrawing.isInMonth) {

		rClassNames.push("outOfMonth");

	}
	
	if(this._checkIsWeekend(iDay)) {
	
		rClassNames.push("weekend");
	
	}

	return rClassNames.join(" ");

}

//Private Draw Methods
Calendar.prototype._drawCloseElement = function(){

	var oClose = Element.create(this.closeElement,{className:"close"},"Close",this.CalendarElement);

	Events.add({
		element:oClose
		,type:"click"
		,handler:this.close
		,context:this
	});

}

Calendar.prototype._drawMonthLabel = function() {

	//Element.create("label", {id:"label-calendar-" + this.selectLabel}, null, this.CalendarElement);

	var oDate = this._currentDate;

	var sMonth = this.MONTH_LABELS[oDate.getMonth()][this.monthDisplay];

	var sYear = oDate.getFullYear();

	/*var sMonthHeader = sMonth + " " + sYear;

	Element.create(this.monthHeaderElement,null,sMonthHeader,this.CalendarElement);*/

	var currentMonth = this._currentDate.getMonth();
	var currentYear = this._currentDate.getFullYear();

	var months = this.MONTH_LABELS;
	var monthSelect = Element.create("select", {className:"select-month"}, null, this.CalendarElement);
	for (var i = 0, index = 0; i < months.length; i++) {
		var option = Element.create("option", {value: index}, months[i].full, monthSelect);
		if (index == currentMonth) {
			option.selected = true;
		}
		index++;
	}

	var yearSelect = Element.create("select", {className:"select-year"}, null, this.CalendarElement);
	var years = [];
	for (var x = new Date().getFullYear(), end = this.getYearMinimum(); x >= end; x--) {
		var option = Element.create("option", {value:x}, x, yearSelect);
		if (x == currentYear) {
			option.selected = true;
		}
	}

	var a = Element.parseSelector("select", this.CalendarElement);
	for (var i = 0; i < a.length; i++) {
		Events.add({
			element: a[i]
			,type: "change"
			,context: this
			,handler: function(e, el) {
				var monthSelect = Element.parseSelector(".select-month", this.CalendarElement, "first");
				var yearSelect  = Element.parseSelector(".select-year",  this.CalendarElement, "first");

				var month = monthSelect.value;//Form.Element.getValue(monthSelect);
				var year  = yearSelect.value;//Form.Element.getValue(yearSelect);

				var oNewDate = new Date(year,month,1);

				this._setCalendarElement();

				this._setCurrentDate(oNewDate);

				this.draw();

			}
		})
	}
	/*Behaviour.apply({
		'select' : {
			'change' : function(e, el) {
				var monthSelect = Element.parseSelector(".select-month", this.CalendarElement, "first");
				var yearSelect  = Element.parseSelector(".select-year",  this.CalendarElement, "first");

				var month = Form.Element.getValue(monthSelect);
				var year  = Form.Element.getValue(yearSelect);

				var oNewDate = new Date(year,month,1);

				this._setCalendarElement();

				this._setCurrentDate(oNewDate);

				this.draw();

			}.Context(this)
		}
	}, this.CalendarElement);*/

}

Calendar.prototype._drawTitle = function(){

	if(this._title){

		Element.create(this.titleHeaderElement,null,this._title,this.CalendarElement);

	}

}

Calendar.prototype._drawCalendarTable = function(){

	var oTableHeader = this._getDayLabels();

	var oCalendarBody = this._getCalendarBody();

	var rTBody = [oTableHeader].concat(oCalendarBody);

	var oTBody = Element.create("tbody",null,rTBody,null);

	this.CalendarTable = Element.create("table",{cellSpacing:0,cellPadding:0},oTBody,this.CalendarElement);

}

Calendar.prototype._drawIncrementButtons = function(){

	var oThis = this;

	var oPrev = Element.create("a",{className:"calendarPreviousMonth",href:"javascript:void(0);"},"Previous",null);

	var oNext = Element.create("a",{className:"calendarNextMonth",href:"javascript:void(0);"},"Next",null);

	//switch out to adding inline events above - place I am working on this only has Element.2 so this is not available

	Events.add({

		element:oNext
		,type:"click"
		,handler:this.incrementMonth
		,context:this

	});

	Events.add({

		element:oPrev
		,type:"click"
		,handler:this.decrementMonth
		,context:this

	});

	Element.addChild(this.CalendarElement,oPrev);

	Element.addChild(this.CalendarElement,oNext);

}

Calendar.prototype._getDayLabels = function(){

	var rTH = [];

	for(var i=0;i<7;i++) {

		rTH.push(

			Element.create("th",{'class':(i == 0 || i == 6) ? "weekend" : ""},this.DAYS[i][this.dayDisplay],null)

		);

	}

	return Element.create("tr",null,rTH,null);

}

Calendar.prototype._getCalendarBody = function(){

	var iFirstDay = this._getFirstDayOfMonth();

	var iDaysInMonth = this._getDaysInMonth();

	var rTRs = [];

	var iDay = 1-iFirstDay;

	for(var iWeek=0;iWeek<6;iWeek++) {

		var rTDs = [];

		for(var i=7*iWeek+1;i<7*(iWeek+1)+1;i++){

			this._setDayDrawing(iDay); //object storing properties for current day being drawn

			iDay++;

			if(iDay<=iDaysInMonth+1 && iDay>1){

				this._dayDrawing.isInMonth = true;

			}

			var sTDClass = this._getDateClass(iDay);

			var oTD = Element.create("td",{className:sTDClass},this._dayDrawing.day,null);

			if(!new RegExp(/disabled/).test(sTDClass)) {

				Events.add({

					element:oTD
					,type:"click"
					,handler:this.selectDay
					,context:this
					,data:{
						date:this._dayDrawing.Date
					}

				});

			}

			rTDs.push(oTD);

		}

		rTRs.push(Element.create("tr",null,rTDs,null));

		if(this._dayDrawing.month != this._currentDate.getMonth() || iDaysInMonth == this._dayDrawing.day) {

			break;

		}

	}

	return rTRs;

}

/* Private Event Adding Methods */

/*
FILE CONCAT ADD FILE
PATH: /ft/resources/client/modules/companyAnnouncements.js
*/

var companyAnnouncements = function() {
}

companyAnnouncements.prototype.ACTION_MAP = {
	 'filter':           'filter'
	,'showAnnouncement': 'showAnnouncement'
};

companyAnnouncements.prototype.BUFFER_CONTENT_TYPE = 'text/html';
companyAnnouncements.prototype.BUFFER_URL = '/ft/resources/buffer/companyAnnouncements/CompanyAnnouncements.asp';

companyAnnouncements.prototype.DATE_VALUE_FOR_POPUP_CALENDAR = 'custom';

companyAnnouncements.prototype.KEY_CODE_ENTER = 13;

companyAnnouncements.prototype.KEYWORD_DEFAULT_TEXT = 'Keyword';

companyAnnouncements.prototype.LANGUAGE_DEFAULT = 'en';

companyAnnouncements.prototype.SEARCH_ALL_CHOICES = 'all';

companyAnnouncements.prototype.SYMBOL_DEFAULT_TEXT = 'Enter name or symbol';

companyAnnouncements.prototype.filterAnnouncements = function(ev, el) {
	if (ev) { ev.cancel(); }

	el.blur();

	this.isFilter = true;

	var data = {
		'action': this.ACTION_MAP['filter']
	};

	if (Element.hasClass(el, 'reset')) {
		this.resetForm();
	}
	else if (Element.hasClass(el, 'nav-icon')) {
		var wsod = Element.get('wsod');

		var pagingNavigation = Element.parseSelector('DIV.pagingNavigation', wsod, 'first');

		var currentRow = Number(pagingNavigation.getAttribute('currentrow'));
		var rowsPerPage = Number(pagingNavigation.getAttribute('rowsperpage'));

		if (Element.hasClass(el, 'nav-left-active')) {
			data.startRow = currentRow - rowsPerPage;
		}
		else if (Element.hasClass(el, 'nav-right-active')) {
			data.startRow = currentRow + rowsPerPage;
		}
	}

	data.isFilter = this.isFilter;

	if (this.SEARCH_ALL_CHOICES != this.country.value) {
		data.country = this.country.value;
	}

	if (this.SEARCH_ALL_CHOICES != this.date.value) {
		data.date = this.date.value;

		var selectedDatesValue = this.selectedDates.getAttribute('selectedDatesValue') || false;
		if (selectedDatesValue && selectedDatesValue.length) {
			data.selectedDates = selectedDatesValue;
		}
	}

	if (this.keywordOrISIN.value.length && (this.KEYWORD_DEFAULT_TEXT != this.keywordOrISIN.value)) {
		var selectedContent = this.content.options[this.content.selectedIndex].value;

		if ('headline' == selectedContent) {
			data.headline = this.keywordOrISIN.value;
		}
		else if ('release' == selectedContent) {
			data.release = this.keywordOrISIN.value;
		}
	}

	if (this.SEARCH_ALL_CHOICES != this.language.value) {
		data.language = this.language.value;
	}

	if (this.SYMBOL_DEFAULT_TEXT != this.symbol.value) {
		data.symbol = this.symbol.value;
	}

	if (this.calendarPopup) {
		this.calendarPopup.close();
	}

	var investorRelationsPopup = Element.parseSelector('DIV.investorRelationsPopup', Element.get('wsodPop'), 'first') || false;
	if (investorRelationsPopup) {
		Element.remove(investorRelationsPopup);
	}

	this.loading.showLoading();

	this.loadContentBuffer(data);
}

companyAnnouncements.prototype.getEventManagerForCompanyAnnouncements = function() {
	var em = new EventManager();
	
	this.getEventManagerForCompanyAnnouncements = function() {
		return em;
	}
	
	return this.getEventManagerForCompanyAnnouncements();
}

companyAnnouncements.prototype.handleTheKeypress = function(ev, el) {
	if (this.KEY_CODE_ENTER == ev.nativeEvent.keyCode) {
		// var el = ev.nativeEvent.target || ev.nativeEvent.srcElement;

		this.filterAnnouncements(ev, el);
	}
}

companyAnnouncements.prototype.init = function() {
	var wsod = Element.get('wsod');
	this.loading = new LoadingOverlay(wsod);
	this.searchForm = Element.get('searchAllAnnouncements');

	this.symbol = Element.parseSelector('DIV.companySymbolSearch INPUT', this.searchForm, 'first') || false;
	if (this.symbol) {
		this.getEventManagerForCompanyAnnouncements().add(this.symbol, 'focus', Common.focusText, Common);
		this.getEventManagerForCompanyAnnouncements().add(this.symbol, 'blur', Common.blurText, Common);

		// Possible enhancement to support "enter" keypress events; might require changes to the related module's init / render
		// this.getEventManagerForCompanyAnnouncements().add(this.symbol, 'keypress', this.handleTheKeypress, this);

		this.setSymbolSearch();
	}

	this.content = Element.get('content');
	this.country = Element.get('country');
	this.language = Element.get('language');

	this.calendarPopup = false;
	this.date = Element.get('date');
	this.selectedDates = Element.get('selectedDates');
	this.getEventManagerForCompanyAnnouncements().add(this.date, 'change', this.showOrHideCalendar, this);
	this.getEventManagerForCompanyAnnouncements().add(this.selectedDates, 'click', this.showOrHideCalendar, this);

	this.keywordOrISIN = Element.get('keywordOrISIN');
	this.getEventManagerForCompanyAnnouncements().add(this.keywordOrISIN, 'focus', Common.focusText, Common);
	this.getEventManagerForCompanyAnnouncements().add(this.keywordOrISIN, 'blur', Common.blurText, Common);

	var filterContainer = Element.get('filterContainer');
	var filterInnerButton = Element.parseSelector('DIV.filter DIV', filterContainer, 'first');
	this.getEventManagerForCompanyAnnouncements().add(filterInnerButton, 'click', this.filterAnnouncements, this);

	var pagingNavigation = Element.parseSelector('DIV.pagingNavigation', wsod, 'first');
	var navIcons = Element.parseSelector('A.nav-icon', pagingNavigation);
	if (navIcons && navIcons.length) {
		this.getEventManagerForCompanyAnnouncements().add(navIcons, 'click', this.filterAnnouncements, this);
	}

	var breadcrumbs = Element.parseSelector('A.breadcrumb', wsod);
	if (breadcrumbs && breadcrumbs.length) {
		this.getEventManagerForCompanyAnnouncements().add(breadcrumbs, 'click', this.filterAnnouncements, this);
	}

	var headlineKeys = Element.parseSelector('A.headlineKey', wsod);
	if (headlineKeys && headlineKeys.length) {
		this.getEventManagerForCompanyAnnouncements().add(headlineKeys, 'click', this.showAnnouncement, this);
	}
}

companyAnnouncements.prototype.resetForm = function() {
	this.isFilter = false;

	this.content.selectedIndex = 0;
	this.country.selectedIndex = 0;

	this.date.selectedIndex = 0;
	Element.setHTML(this.selectedDates, '');
	Element.setAttribute(this.selectedDates, 'selectedDatesValue', '');

	this.keywordOrISIN.value = this.KEYWORD_DEFAULT_TEXT;
	this.symbol.value = this.SYMBOL_DEFAULT_TEXT;

	var currentLanguage;
	var languageOptions = (this.language && this.language.options) ? this.language.options : 0;

	for (var i = 0; i < languageOptions.length; i++) {
		currentLanguage = languageOptions[i];

		if (this.LANGUAGE_DEFAULT == currentLanguage.value) {
			this.language.selectedIndex = i;
			break;
		}
	}
}

companyAnnouncements.prototype.setSymbolSearch = function() {
	var self = this;

	var s = new SymbolSearch();
		s.setForm(this.searchForm);
		s.setRequestor(new ContentBuffer());

		s.moreResultsPopupMode(true);
		s.moreResultsHandlerCallback(
			function(popup, parent) {
				var elLinks = Element.parseSelector('.interactiveChartLink', parent || Element.get('wsod'));

				Events.add(elLinks, 'click', function(e, el) {
					e.cancel();

					var symbol = el.getAttribute('intchartsymbol');
					var issueName = el.getAttribute('issuename');

					self.symbol.value = symbol;
	
					popup.close();
				}.Context(this));		
			}, this
		);

		s.go = function(symbol) {
			this.clearResults();

			self.symbol.value = symbol;
		};
}

companyAnnouncements.prototype.showAnnouncement = function(ev, el) {
	if (ev) { ev.cancel(); }

	var data = {
		 'action':      this.ACTION_MAP['showAnnouncement']
		,'headlineKey': el.getAttribute('headlineKey')
	};

	if (this.calendarPopup) {
		this.calendarPopup.close();
	}

	var investorRelationsPopup = Element.parseSelector('DIV.investorRelationsPopup', Element.get('wsodPop'), 'first') || false;
	if (investorRelationsPopup) {
		Element.remove(investorRelationsPopup);
	}

	this.loading.showLoading();

	this.loadContentBuffer(data);
}

companyAnnouncements.prototype.showOrHideCalendar = function(ev, el) {
	if (ev) { ev.cancel(); }

	var date = Element.get('date');
	var selectedDateValue = date.options[date.selectedIndex].value;

	this.calendarPopup = this.calendarPopup || new CalendarPopup();

	if (this.DATE_VALUE_FOR_POPUP_CALENDAR == selectedDateValue) {
		var oArgs = {
			'yearMinimum': '2009'
		};

		this.calendarPopup.setCallback(this.updateSelectedDates, this);
		this.calendarPopup.init(oArgs);
	}
	else {
		Element.setHTML(this.selectedDates, '');
		Element.setAttribute(this.selectedDates, 'selectedDatesValue', '');

		var calendarPopup = Element.parseSelector('DIV.calendarPopup', Element.get('wsodPop'), 'first') || false;

		if (calendarPopup) {
			Element.addClass(calendarPopup, 'wsodHidden');
		}
	}
}

companyAnnouncements.prototype.loadContentBuffer = function(data) {
	data = data || {};

	var serializedData = Common.getSerializer().serialize(data);
	var methodForOnLoad;

	if (this.ACTION_MAP['showAnnouncement'] == data.action) {
		methodForOnLoad = this.onLoadForShowAnnouncement;
	}
	else {
		// this.ACTION_MAP['filterAnnouncement']
		methodForOnLoad = this.onLoad;
	}

	var contentBuffer = new ContentBuffer();
		contentBuffer.abortRequests();
		contentBuffer.load(
			{
				 contentType: data.contentType || this.BUFFER_CONTENT_TYPE
				,context:     this
				,data:        { serializedData:serializedData }
				,onload:      methodForOnLoad
				,onerror:     this.onError
				,preventEval: true
				,url:         this.BUFFER_URL
			}
		);
}

companyAnnouncements.prototype.onError = function(cb) {
	var results = cb.getResult() || '';
	// console.log(results);

	this.loading.hideLoading();
}

companyAnnouncements.prototype.onLoad = function(cb) {
	var results = cb.getResult() || '';

	var resultsModuleContainer = Element.get('resultsModuleContainer');

	Element.addClass(resultsModuleContainer, 'hidden');

	Element.setHTML(resultsModuleContainer, results);

	var wsod = Element.get('wsod');

	var pagingNavigation = Element.parseSelector('DIV.pagingNavigation', wsod, 'first');
	var navIcons = Element.parseSelector('A.nav-icon', pagingNavigation) || false;
	if (navIcons) {
		this.getEventManagerForCompanyAnnouncements().add(navIcons, 'click', this.filterAnnouncements, this);
	}

	var breadcrumbs = Element.parseSelector('A.breadcrumb', wsod);
	if (breadcrumbs && breadcrumbs.length) {
		this.getEventManagerForCompanyAnnouncements().add(breadcrumbs, 'click', this.filterAnnouncements, this);
	}

	var headlineKeys = Element.parseSelector('A.headlineKey', wsod);
	if (headlineKeys && headlineKeys.length) {
		this.getEventManagerForCompanyAnnouncements().add(headlineKeys, 'click', this.showAnnouncement, this);
	}

	var investorRelations = new InvestorRelations();
		investorRelations.init();

	Element.removeClass(resultsModuleContainer, 'hidden');

	this.loading.hideLoading();
}

companyAnnouncements.prototype.onLoadForShowAnnouncement = function(cb) {
	var results = cb.getResult() || '';

	var resultsModuleContainer = Element.get('resultsModuleContainer');
	Element.addClass(resultsModuleContainer, 'hidden');
	Element.setHTML(resultsModuleContainer, results);

	var wsod = Element.get('wsod');

	var breadcrumbs = Element.parseSelector('A.breadcrumb', wsod);
	if (breadcrumbs && breadcrumbs.length) {
		this.getEventManagerForCompanyAnnouncements().add(breadcrumbs, 'click', this.filterAnnouncements, this);
	}

	Element.removeClass(resultsModuleContainer, 'hidden');

	this.loading.hideLoading();
}


companyAnnouncements.prototype.updateSelectedDates = function(startDate, endDate) {
	startDate = startDate || false;
	endDate = endDate || false;

	var startYear, startMonth, startDay, endYear, endMonth, endDay, adjustedStartMonth, adjustedEndMonth;

	if (startDate) {
		startYear = startDate.getFullYear();
		startMonth = startDate.getMonth();
		startDay = startDate.getDate();

		adjustedStartMonth = Number(startMonth) + 1;
	}

	if (endDate) {
		endYear = endDate.getFullYear();
		endMonth = endDate.getMonth();
		endDay = endDate.getDate();

		adjustedEndMonth = Number(endMonth) + 1;
	}

	var selectedDates = Element.get('selectedDates');

	Element.setHTML(selectedDates, [ startDay, '/', adjustedStartMonth, '/', startYear, ' - ', endDay, '/', adjustedEndMonth, '/', endYear ].join(''));
	Element.setAttribute(selectedDates, 'selectedDatesValue', [ startYear, '-', adjustedStartMonth, '-', startDay, '|', endYear, '-', adjustedEndMonth, '-', endDay ].join(''));
}

/*
FILE CONCAT ADD FILE
PATH: /ft/resources/client/markets/Finder.js
*/
var Finder = function(){
};

Finder.prototype.CSS_LOADING = "loading";
Finder.prototype.CSS_SELECTED = "selected";
Finder.prototype.CSS_HIDDEN = "wsodHidden";

Finder.prototype.init = function() {
	this.container = Element.get("marketFinderContainer");
	this.regionSelect = Element.get("marketFinderRegionSelect");
	this.countrySelect = Element.get("marketFinderCountrySelect");
	this.query = Element.get("marketFinderField");
	var form = Element.parseSelector("form", this.container, "first");
	var button = Element.parseSelector("div.basicButton", this.container, "first");
	
	Events.add(form, "submit", this.handleSubmit, this);
	Events.add(button, "click", function() {
		form.submit();
	});
	Events.add(this.query, "focus", function(e, el) {
		el.select();
	});
	
	if (this.regionSelect) {
		Events.add({
			element: this.regionSelect,
			type: "change",
			handler: this.changeCountrySelect,
			context:this	
		});
	}
	
	this.initResultEvents();
};

Finder.prototype.initResultEvents = function() {
	this.results = Element.get("searchResults");
	this.resultContainers = Element.parseSelector("div.resultContainer", this.results);
	
	SortableTable.initAllSortableTables(GroupedSortableTable);
	
	this.tabs = Element.parseSelector("ul.wsod-tabs-main a", this.results);
	if (this.tabs) {
		this.getTabSwitchEvent().removeAllElements();
		this.getTabSwitchEvent().addElement(this.tabs);
	}
};

Finder.prototype.getTabSwitchEvent = function() {
	var e = Events.add(null, "click", this.switchResultType, this);
	
	this.getTabSwitchEvent = function() {
		return e;
	};
	
	return this.getTabSwitchEvent();
};

Finder.prototype.getBuffer = function() {
	var cb = new ContentBuffer();
	
	this.getBuffer = function() {
		return cb;
	};
	
	return this.getBuffer();
};

Finder.prototype.getFormSerializer = function() {
	var fs = new FormSerializerLite();
	
	this.getFormSerializer = function() {
		return fs;
	};
	
	return this.getFormSerializer();
};

Finder.prototype.switchResultType = function(e, el) {
	e.cancel();
	el.blur();
	if (!Element.hasClass(el.parentNode, this.CSS_SELECTED)) {
		
		for (var i=0;i<this.tabs.length;i++) {
			Element.removeClass(this.tabs[i].parentNode, this.CSS_SELECTED);
		}
		Element.addClass(el.parentNode, this.CSS_SELECTED);
		
		var resultType = el.getAttribute("type");
		Element.addClass(this.resultContainers, this.CSS_HIDDEN);
		Element.removeClass(Element.get("results-" + resultType), this.CSS_HIDDEN);
		var groupField = Element.get("selectedResultGroup");
		if(groupField) groupField.value = resultType;
	}
};

Finder.prototype.setCountries = function(countries) {
	this.countries = countries;
};

Finder.prototype.changeCountrySelect = function() {
	if (this.regionSelect && this.countrySelect) {
		var regionKey = this.regionSelect.value;

		if(this.countrySelect.childNodes) {
			Element.removeChildNodes(this.countrySelect);
		}
		
		if("GBL" != regionKey) {
			//this.countrySelect.disabled = false;
			for(var key in this.countries) {
				if (regionKey == this.countries[key].regionCode){
					Element.create("option",{value:key},this.countries[key].name, this.countrySelect);
				}
			}
		} else {
			Element.create("option", {value:""}, " - Select Region - ", this.countrySelect);
			//this.countrySelect.disabled = true;
		}
		
	}	
};

Finder.prototype.handleSubmit = function(e, el) {
	e.cancel();
	
	if (trim(this.query.value)) {
		this.showLoading();
		this.getBuffer().abortRequests();
		
		this.getBuffer().load({
			url: "/ft/markets/data/getFinderResults.asp",
			data: {
				params: this.getFormSerializer().serialize(el)
			},
			onload: this.drawResults,
			onerror: this.drawError,
			context: this
		});
	}
	else {
		// this.error()
	}
};

Finder.prototype.drawResults = function(cb) {
	Element.removeChildNodes(this.results);
	Element.setHTML(this.results, cb.getResult());
	this.initResultEvents();
	this.hideLoading();
};
Finder.prototype.drawError = function(cb) {
	Element.removeChildNodes(this.results);
	Element.setHTML(this.results, "<p>Sorry, no results were found for your query \"" + this.query.value + "\"</p>");
	this.initResultEvents();
	this.hideLoading();
};

Finder.prototype.showLoading = function() {
	Element.addClass(this.results, this.CSS_LOADING);
};
Finder.prototype.hideLoading = function() {
	Element.removeClass(this.results, this.CSS_LOADING);
};

// just the header form as a standalone
var FinderModule = function() {
	FinderModule.Super(this);
};
FinderModule.Extend(Finder);

FinderModule.prototype.handleSubmit = function(e, el) {
	e.cancel();
	
	if (trim(this.query.value)) {
		el.submit();
	}
};

// mini side module
var MiniFinderModule = function() {
	MiniFinderModule.Super(this);
	
	this.advancedOptionsLink = Element.parseSelector("a.advancedOptions",this.container,"first");
	this.advancedOptionsContainer = Element.parseSelector("div.advancedOptionsContainer",this.container,"first");
	
	this.isAdvancedOptionsOpened = false;
	
	this.advancedOptLinkExpand = "+";
	this.advancedOptLinkCollapse = "-";
	this.advancedOptLinkText = "Advanced Options";
	
};

MiniFinderModule.Extend(Finder);

MiniFinderModule.prototype.init = function() {
	MiniFinderModule.Super(this, "init");
	if (this.advancedOptionsLink) {
		Events.add({
			element: this.advancedOptionsLink,
			type: "click",
			handler: this.toggleAdvancedOptions,
			context:this	
		});
	}
	//this.regionSelect.options[0].selected = true;
};

MiniFinderModule.prototype.initResultEvents = function() {
	// do nothing please
};

MiniFinderModule.prototype.toggleAdvancedOptions = function (e,el,args) {
	e.cancel();
	el.blur();
	if (this.advancedOptionsLink && this.advancedOptionsContainer) {
		if(!this.isAdvancedOptionsOpened){
			Element.removeClass(this.advancedOptionsContainer,"wsodHidden");
			this.isAdvancedOptionsOpened = true;
			var display = this.advancedOptLinkCollapse + ' '+ this.advancedOptLinkText;
			Element.setHTML(this.advancedOptionsLink, display);
		} else {
			Element.addClass(this.advancedOptionsContainer,"wsodHidden");
			this.isAdvancedOptionsOpened = false;
			var display = this.advancedOptLinkExpand + ' '+ this.advancedOptLinkText;
			Element.setHTML(this.advancedOptionsLink, display);
		}
	}
};

MiniFinderModule.prototype.handleSubmit = function(e, el) {
	e.cancel();
	
	if (trim(this.query.value)) {
		el.submit();
	}
};
/*
FILE CONCAT ADD FILE
PATH: /ft/resources/client/markets/InvestorRelations.js
*/

function InvestorRelations() {}

InvestorRelations.Extend(Popup);

// Constants
InvestorRelations.prototype.CSS_BOLD				= 'bold';
InvestorRelations.prototype.CSS_HIDDEN				= 'wsodHidden';
InvestorRelations.prototype.CSS_HIGHLIGHT			= 'highlight';
InvestorRelations.prototype.CSS_LOADING				= 'loading';
InvestorRelations.prototype.CSS_WIDGET				= 'investorRelationsIcons';
InvestorRelations.prototype.MAX_LENGTH_FOR_SEARCH	= 150;
InvestorRelations.prototype.DEFAULT_SORT_FIELD		= 'Name';
InvestorRelations.prototype.DEFAULT_SORT_DIR		= 'asc';
InvestorRelations.prototype.POPUP_TITLE				= 'Investor Relations Content';
InvestorRelations.prototype.LINK_URL				= '/ft/tearsheets/performance.asp';

InvestorRelations.prototype.WIDGET_TABLE_HEADERS 	= {
	"Name":{"key":"Name", "name":"Company", "css":"sortable text"},
	"Sector":{"key":"Sector", "name":"Sector", "css":"sortable text"},
	"Industry":{"key":"Industry", "name":"Industry", "css":"sortable text"},
	"Country":{"key":"Country", "name":"Country", "css":"sortable text"},
	"InvestorRelationsContent":{"key":"InvestorRelationsContent ", "name":"Investor Relations Content", "css":"text"}
};
InvestorRelations.prototype.WIDGET_TYPES 			= {
	"annualreports":{"key":"annualreports", "name":"Annual Reports", "css": "icon-widget-annualreports"},
	"events":{"key":"events", "name":"Calendar", "css": "icon-widget-events"},
	"podcast":{"key":"podcast", "name":"Podcast", "css": "icon-widget-podcast"},
	"contacts":{"key":"contacts", "name":"Contact Details", "css": "icon-widget-contacts"},
	"newsfeed":{"key":"newsfeed", "name":"News Feed", "css": "icon-widget-newsfeed"},
	"video":{"key":"video", "name":"Video", "css": "icon-widget-video"},
	"slides":{"key":"slides", "name":"Slideshow", "css": "icon-widget-slides"},
	"links":{"key":"links", "name":"Further Info", "css": "icon-widget-links"},
	"other": {"key": "other", "name": "Other", "css": "icon-widget-other" }
};
InvestorRelations.prototype.ALPHABET = [
	{"label":"Select a letter"},
	{"label":"A", "value":"a"},
	{"label":"B", "value":"b"},
	{"label":"C", "value":"c"},
	{"label":"D", "value":"d"},
	{"label":"E", "value":"e"},
	{"label":"F", "value":"f"},
	{"label":"G", "value":"g"},
	{"label":"H", "value":"h"},
	{"label":"I", "value":"i"},
	{"label":"J", "value":"j"},
	{"label":"K", "value":"k"},
	{"label":"L", "value":"l"},
	{"label":"M", "value":"m"},
	{"label":"N", "value":"n"},
	{"label":"O", "value":"o"},
	{"label":"P", "value":"p"},
	{"label":"Q", "value":"q"},
	{"label":"R", "value":"r"},
	{"label":"S", "value":"s"},
	{"label":"T", "value":"t"},
	{"label":"U", "value":"u"},
	{"label":"V", "value":"v"},
	{"label":"W", "value":"w"},
	{"label":"X", "value":"x"},
	{"label":"Y", "value":"y"},
	{"label":"Z", "value":"z"}
];

/**
 * @method init
 */
InvestorRelations.prototype.init = function() {
	this.buttonForFilter				= WSDOM.Element.get('buttonForFilter') || false;
	this.buttonForSearch				= WSDOM.Element.get('buttonForSearch') || false;
	this.currentCountry					= '';
	this.currentExchange				= '';
	this.currentLetter					= '';
	this.nameOrPartialName				= WSDOM.Element.get('nameOrPartialName') || false;
	this.matchesModule					= WSDOM.Element.get('matchesModule') || false;
	this.menuOfCountries				= WSDOM.Element.get('menuOfCountries');
	this.menuOfExchanges				= WSDOM.Element.get('menuOfExchanges');
	this.menuOfLetters					= WSDOM.Element.get('menuOfLetters');
	this.menuOfLettersDefault           = WSDOM.Element.get('menuOfLettersDefault');
	this.searchModule					= WSDOM.Element.get('searchModule') || false;
	this.wsod							= WSDOM.Element.get('wsod');
	this.irIcons						= WSDOM.Element.parseSelector("a.investorRelationsIcons", this.wsod);
	
	this.attachEvents();
	this.correctTableSort();
	
	if (this.matchesModule) {
		this.getPaging().setContentContainer(this.matchesModule);
	}
	
	if (this.searchModule) {
		this.loadingOverlay = new LoadingOverlay(this.searchModule);
	}
}


/**
 * @method attachEvents
 */
InvestorRelations.prototype.attachEvents = function() {
	if (this.buttonForSearch) {
		Events.add({element: this.buttonForSearch, context:	this, type: 'click', handler: this.searchByCompanyName});
		Events.add({element: this.nameOrPartialName, context: this, type: 'keypress', handler:	this.handleTheKeypressForSearchByCountryName});
	}

	if (this.buttonForFilter) {
		Events.add({element: this.buttonForFilter, context: this, type: 'click', handler: this.filterByCountryOrExchange});
	}
	
	if (this.irIcons && this.irIcons.length) {
		Events.add({element: this.irIcons, context: this, type: "click", handler: this.drawPopup});
	}
}

// we do this client side so that we can use TableBuilder on the server side and still have threading
InvestorRelations.prototype.correctTableSort = function() {
	for (var i = 0, parent; i < this.irIcons.length; i++) {
		parent = Element.getParent(this.irIcons[i], "td");
		
		if (parent && "TD" == parent.tagName) {
			parent.setAttribute("sortval", 1);
		}
	}
}

InvestorRelations.prototype.getPaging = function() {
	var p = new Paging();
	
	this.getPaging = function() {
		return p;
	}
	
	return this.getPaging();
}

/**
 * @method getSerializer
 */
InvestorRelations.prototype.getSerializer = function() {
	var serializer = new Serializer();
		// serializer.allowEncoding(true);

	this.getSerializer = function() {
		return serializer;
	}

	return this.getSerializer();
}

InvestorRelations.prototype.getEventManager = function() {
	var em = new EventManager();
	
	this.getEventManager = function() {
		return em;
	}
	
	return this.getEventManager();
}


/**
 * @method trim
 */
InvestorRelations.prototype.trim = function(string) {
	return string.replace(/^\s+/, '').replace(/\s+$/, '');
}


/**
 * @method handleTheKeypressForSearchByCountryName
 */
InvestorRelations.prototype.handleTheKeypressForSearchByCountryName = function(e) {
	// If the user presses the "Enter" key, run the search
	if ('13' == e.nativeEvent.keyCode) {
		var el = e.nativeEvent.target || e.nativeEvent.srcElement;
			el.blur();  // Otherwise, Firefox will put the focus back on the <INPUT>
			window.focus();  // IE 6 does not support el.blur()

		this.searchByCompanyName();
	}else{
		this.currentLetter = '';
		Element.setHTML(this.menuOfLettersDefault, "Select a letter")
		//console.log(this.nameOrPartialName.value)
	}
	
}


/**
 * @method searchByCompanyName
 */
InvestorRelations.prototype.searchByCompanyName = function() {
	if(this.currentLetter != ''){
		this.searchByLetter()
		return;
	}else{
		if (this.nameOrPartialName) {
			if (!this.nameOrPartialName.value || '' == this.trim(this.nameOrPartialName.value)) {
				alert('Please enter a company name or select a letter.');
				this.nameOrPartialName.value = '';
			}
			else if (this.nameOrPartialName.value.length > this.MAX_LENGTH_FOR_SEARCH) {
				alert('Please limit your search to ' + this.MAX_LENGTH_FOR_SEARCH + ' characters or less.');
			}
			else {
				this.setContentBufferData({
					 action:		"search"
					,companyName:	this.nameOrPartialName.value
				});

				this.loadContentBuffer();
			}
		}
	}
}

/**
 * @method searchByLetter
 */
InvestorRelations.prototype.searchByLetter = function() {
	this.setContentBufferData({
		 action:		"search"
		,searchLetter:	this.currentLetter
	});

	this.loadContentBuffer();
}


/**
 * @method filterByCountryOrExchange
 */
InvestorRelations.prototype.filterByCountryOrExchange = function() {
	var runTheFilter = false;

	var data = {
		action: "filter"
	};

	if (this.currentCountry) {
		data.country	= this.currentCountry;
		runTheFilter	= true;
	}

	if (this.currentExchange) {
		data.exchange	= this.currentExchange;
		runTheFilter	= true;
	}

	if (runTheFilter) {
		this.setContentBufferData(data);
		this.loadContentBuffer();
	}
	else {
		alert('Please select a country and/or an exchange to filter on.');
	}
}

InvestorRelations.prototype.sortResults = function(e, el) {
	var ths = Element.parseSelector("th.sortable", "tableOfMatches");
	
	var sortField = el.getAttribute("sortField");
	var sortDir = Element.hasClass(el, "asc") ? "desc" : "asc";

	Element.removeClass(ths, "sorted");
	Element.removeClass(ths, "asc");
	Element.addClass(el, "sorted "+sortDir);
	
	var data = this.getContentBufferData();
		data.sortField = sortField;
		data.sortDir = sortDir;

	this.setContentBufferData(data);
	this.loadContentBuffer(true);
}

/**
 * @method getContentBuffer
 */
InvestorRelations.prototype.getContentBuffer = function() {
	var contentBuffer = new ContentBuffer();

	this.getContentBuffer = function() {
		return contentBuffer;
	}

	return this.getContentBuffer();
}

InvestorRelations.prototype.getContentBufferData = function() { return {}; }
InvestorRelations.prototype.setContentBufferData = function(data) {
	this.getContentBufferData = function() {
		return data;
	}
}

/**
 * @method loadContentBuffer
 */
InvestorRelations.prototype.loadContentBuffer = function(disableLoading) {
	if (!disableLoading && this.loadingOverlay) {
		this.loadingOverlay.showLoading();
	}

	this.getContentBuffer().abortRequests();  // If the user happens to click several buttons, only load the most recent request
	this.getContentBuffer().load({
		contentType:	'text/javascript'
		,context:		this
		,url:			'/ft/resources/buffer/InvestorRelationsBuffer.asp'
		,method:		'post'
		,data:			this.getContentBufferData()
		,onload:		this.onBufferLoad
		,onerror:		this.onBufferError
		,preventEval:	true
		//,debug:			true
	});
}

InvestorRelations.prototype.getBufferResults = function() { return {}; }
InvestorRelations.prototype.setBufferResults = function(cb) {
	var deserializedResults = this.getSerializer().deserialize(cb.getResult());
	
	this.getBufferResults = function() {
		return deserializedResults;
	}
}

// This call does not instantiate paging.
InvestorRelations.prototype.onBufferLoadPaging = function(cb) {
	if (cb) { window.scrollTo(0, WSDOM.Element.getXY("searchModule").y); }
	
	if (cb) { this.setBufferResults(cb); }
	
	this.getEventManager().removeAll();
	
	var deserializedResults = this.getBufferResults();
	var companies = deserializedResults && deserializedResults.companies ? deserializedResults.companies : [];
	var sortField = deserializedResults && deserializedResults.sortField ? deserializedResults.sortField : this.DEFAULT_SORT_FIELD;
	var sortDir	  = deserializedResults && deserializedResults.sortDir ? deserializedResults.sortDir : this.DEFAULT_SORT_DIR;
		//console.log(deserializedResults);

	if (this.matchesModule) {
		this.matchesModule.innerHTML = '';
		WSDOM.Element.create('h2', {}, 'Company matches with Investor Relations content available', this.matchesModule);

		if (companies.length) {
			var peersAvailable = false;
			
			var tableBody = WSDOM.Element.create('tbody', {});
			
			for (var i = 0, company, companyName, currentRow, iconsToDisplay; i < companies.length; i++) {
				company = companies[i];
				companyName = !company.isPeer ? company.companyName : companyName;
				
				if (!company.isPeer) {
					currentRow	= WSDOM.Element.create('tr', {}, null, tableBody);

					WSDOM.Element.create('td', { 'class':'text' }, company.companyNameAndSymbol, currentRow);
					WSDOM.Element.create('td', { 'class':'text' }, company.sector.replace('/', ' / '), currentRow);
					WSDOM.Element.create('td', { 'class':'text' }, company.industry, currentRow);
					WSDOM.Element.create('td', { 'class':'text' }, company.country, currentRow);
					iconsToDisplay = WSDOM.Element.create('td', {}, null, currentRow);

					for (var j in this.WIDGET_TYPES) {
						if (company[j]) {
							WSDOM.Element.create('a', { 'href':this.LINK_URL+"?s="+escape(company.FTStandardSymbol)+"&widgets=1", 'class':'investorRelationsIcons '+this.WIDGET_TYPES[j].css, 'title':this.WIDGET_TYPES[j].name }, null, iconsToDisplay);
						}
					}
				} else {
					if (company.isPeer) {
						peersAvailable = true;
					}
				}
			}
			
			if (peersAvailable) {
				var peersHeader = WSDOM.Element.create('tr', {}, null, tableBody);
				WSDOM.Element.create('td', { 'class':'text', colspan:'5', 'style':'background-color:#f6e9d8; padding-left:20px' }, 'Peers of ' + companyName + ' with Investor Relations content', peersHeader);

				for (var i = 0, company; i < companies.length; i++) {
					company = companies[i];
					
					if (company.isPeer) {
						var currentRowForPeers = WSDOM.Element.create('tr', {}, null, tableBody);
	
						WSDOM.Element.create('td', { 'class':'text', 'style':'padding-left:20px' }, company.companyNameAndSymbol, currentRowForPeers);
						WSDOM.Element.create('td', { 'class':'text' }, company.sector, currentRowForPeers);
						WSDOM.Element.create('td', { 'class':'text' }, company.industry, currentRowForPeers);
						WSDOM.Element.create('td', { 'class':'text' }, company.country, currentRowForPeers);
						var iconsToDisplayForPeers = WSDOM.Element.create('td', {}, null, currentRowForPeers);
	
						for (var j in this.WIDGET_TYPES) {
							if (company[j]) {
								WSDOM.Element.create('a', { 'href':this.LINK_URL+"?s="+escape(company.FTStandardSymbol)+"&widgets=1", 'class':'investorRelationsIcons '+this.WIDGET_TYPES[j].css, 'title':this.WIDGET_TYPES[j].name }, null, iconsToDisplayForPeers);
							}
						}
					}
				}
			}
			
			var tableHead = WSDOM.Element.create('thead', {}, tableHeadRow);
			var tableHeadRow = WSDOM.Element.create('tr', {});
			
			var sorted, dir;
			for (var j in this.WIDGET_TABLE_HEADERS) {
				sorted = sortField == this.WIDGET_TABLE_HEADERS[j].key ? " sorted" : "";
				dir = sortField == this.WIDGET_TABLE_HEADERS[j].key ? " "+sortDir : "";
				
				WSDOM.Element.create('th', { 'class':this.WIDGET_TABLE_HEADERS[j].css+sorted+dir, 'sortField': this.WIDGET_TABLE_HEADERS[j].key }, [
					this.WIDGET_TABLE_HEADERS[j].name,
					Element.create('span', { 'class':'th' }, "&nbsp;")
				], tableHeadRow)
			}
			
			Element.addChild(tableHead, tableHeadRow);
		
			var currentTable	= WSDOM.Element.create('table', { id:'tableOfMatches', 'class':'sortable' }, [
				tableHead,
				tableBody
			], this.matchesModule);
		} else {
			WSDOM.Element.create('p', {}, 'Sorry, no matches were found.', this.matchesModule);
		}

		var tableOfMatches = Element.get("tableOfMatches");

		if (tableOfMatches) {
			this.getEventManager().add(Element.parseSelector("th.sortable", tableOfMatches), "click", this.sortResults, this);
		}
		
		if (this.loadingOverlay) {
			this.loadingOverlay.hideLoading();
		}
	}
}

// This call instantiates paging.
InvestorRelations.prototype.onBufferLoad = function(cb) {
	if (cb) { this.setBufferResults(cb); }

	var deserializedResults = this.getBufferResults();
	var companies = deserializedResults && deserializedResults.companies ? deserializedResults.companies : [];
	
	this.onBufferLoadPaging();
	
	if (companies && companies.length) {
 			this.getPaging().setRowsPerPage(deserializedResults.rowsPerPage);
			this.getPaging().setCurrentRow(deserializedResults.startRow);
			this.getPaging().setTotalRows(deserializedResults.totalRows);
			
			this.getPaging().setBufferLoadFunction({
				contentType:	'text/javascript'
				,context:		this
				,url:			'/ft/resources/buffer/InvestorRelationsBuffer.asp'
				,method:		'post'
				,data:			this.getContentBufferData()
				,onload:		this.onBufferLoadPaging
				,onerror:		this.onBufferError
				,preventEval:	true
				,debug:			true
			});
			
			this.getPaging().draw(); 
	}
}


/**
 * @method onBufferLoad
 */
InvestorRelations.prototype.onBufferError = function(cb) {
	var deserializedResults = this.getSerializer().deserialize(cb.getResult());
		// console.log(deserializedResults);

	if (this.matchesModule) {
		this.matchesModule.innerHTML = '';
		WSDOM.Element.create('h2', {}, 'Company matches with Investor Relations content available', this.matchesModule);
		WSDOM.Element.create('p', {}, 'Sorry, no matches were found.', this.matchesModule);
	}
}


InvestorRelations.prototype.getFlyout = function() {
	return new Flyout();
}


InvestorRelations.prototype.getCountriesAndExchanges = function() {
	return null;
}


InvestorRelations.prototype.setCountriesAndExchanges = function(countriesAndExchangesObject) {
	var countriesAndExchanges = this.getSerializer().deserialize(countriesAndExchangesObject) || {};

	this.getCountriesAndExchanges = function() {
		return countriesAndExchanges;
	}

	return this.getCountriesAndExchanges();
}


InvestorRelations.prototype.selectCountry = function(e, item) {
	this.currentCountry		= item.getValue();
	this.currentExchange	= '';

	WSDOM.Element.removeClass(this.getFlyoutControlsForCountries(), this.CSS_HIGHLIGHT);
	WSDOM.Element.addClass(item.getContainer(), this.CSS_HIGHLIGHT);

	WSDOM.Element.removeChildNodes(this.getFlyoutLabelForCountries());
	WSDOM.Element.create('span', {}, item.getLabel(), this.getFlyoutLabelForCountries());

	WSDOM.Element.removeChildNodes(this.getFlyoutLabelForExchanges());
	WSDOM.Element.create('span', {}, 'All exchanges', this.getFlyoutLabelForExchanges());

	var exchanges = this.getFlyoutControlsForExchanges();
	for (var i = 0; i < exchanges.length; i++) {
		if ('All countries' == item.getLabel()) {
			if ('All exchanges' == exchanges[i].innerHTML) {
				WSDOM.Element.addClass(exchanges[i], this.CSS_HIGHLIGHT);
			}
			else {
				WSDOM.Element.removeClass(exchanges[i], this.CSS_HIGHLIGHT);
			}

			WSDOM.Element.removeClass(exchanges[i], this.CSS_HIDDEN);
		}
		else if ('All exchanges' != exchanges[i].innerHTML && !WSDOM.Element.hasClass(exchanges[i], item.getValue())) {
			WSDOM.Element.addClass(exchanges[i], this.CSS_HIDDEN);
			WSDOM.Element.removeClass(exchanges[i], this.CSS_HIGHLIGHT);
		}
		else {
			if ('All exchanges' == exchanges[i].innerHTML) {
				WSDOM.Element.addClass(exchanges[i], this.CSS_HIGHLIGHT);
			}
			else {
				WSDOM.Element.removeClass(exchanges[i], this.CSS_HIGHLIGHT);
			}

			WSDOM.Element.removeClass(exchanges[i], this.CSS_HIDDEN);
		}
	}
}


InvestorRelations.prototype.selectExchange = function(e, item) {
	this.currentExchange	= item.getValue();

	WSDOM.Element.removeClass(this.getFlyoutControlsForExchanges(), this.CSS_HIGHLIGHT);
	WSDOM.Element.addClass(item.getContainer(), this.CSS_HIGHLIGHT);

	WSDOM.Element.removeChildNodes(this.getFlyoutLabelForExchanges());
	WSDOM.Element.create('span', {}, item.getLabel(), this.getFlyoutLabelForExchanges());

}

InvestorRelations.prototype.selectLetter = function(e, item) {
	this.currentLetter	= item.getValue();
	//console.log(this.currentLetter)
	if(this.currentLetter){
		this.nameOrPartialName.value = '';
	}

	WSDOM.Element.removeClass(this.getFlyoutControlsForLetters(), this.CSS_HIGHLIGHT);
	WSDOM.Element.addClass(item.getContainer(), this.CSS_HIGHLIGHT);

	WSDOM.Element.removeChildNodes(this.getFlyoutLabelForLetters());
	WSDOM.Element.create('span', {}, item.getLabel(), this.getFlyoutLabelForLetters());

}

InvestorRelations.prototype.drawMenuOfLetters = function() {
	var flyout = this.getFlyout();
		var shortFlyout = flyout.getFrame()
		Element.addClass(shortFlyout, "shortFlyout")
		
		flyout.setParent(this.wsod);
		flyout.addTarget(this.menuOfLetters);
		flyout.setData(this.ALPHABET);
		flyout.onSelect().addListener(
			{
				 context: this
				,handler: this.selectLetter
			}
		);

	var flyoutLabel		= this.menuOfLetters.firstChild;
	var flyoutControls	= WSDOM.Element.parseSelector('ul li', flyout.getFrame());

	this.drawMenuOfLetters = function() {
		return flyout;
	}

	this.getFlyoutLabelForLetters = function() {
		return flyoutLabel;
	}

	this.getFlyoutControlsForLetters = function() {
		return flyoutControls;
	}

	return this.drawMenuOfLetters();
}

InvestorRelations.prototype.drawMenuOfCountries = function() {
	var flyout = this.getFlyout();
		flyout.setParent(this.wsod);
		flyout.addTarget(this.menuOfCountries);
		flyout.setData(this.getCountriesAndExchanges().countries);
		flyout.onSelect().addListener(
			{
				 context: this
				,handler: this.selectCountry
			}
		);

	var flyoutLabel		= this.menuOfCountries.firstChild;
	var flyoutControls	= WSDOM.Element.parseSelector('ul li', flyout.getFrame());

	this.drawMenuOfCountries = function() {
		return flyout;
	}

	this.getFlyoutLabelForCountries = function() {
		return flyoutLabel;
	}

	this.getFlyoutControlsForCountries = function() {
		return flyoutControls;
	}

	return this.drawMenuOfCountries();
}


InvestorRelations.prototype.drawMenuOfExchanges = function() {
	var exchanges = this.getCountriesAndExchanges().exchanges;
		exchanges.sort(function(a, b) {
			return (a.label < b.label) ? -1 : 1;
		});

	var flyout = this.getFlyout();
		flyout.setParent(this.wsod);
		flyout.addTarget(this.menuOfExchanges);
		flyout.setData(exchanges);
		flyout.onSelect().addListener(
			{
				 context: this
				,handler: this.selectExchange
			}
		);

	var flyoutLabel		= this.menuOfExchanges.firstChild;
	var flyoutControls	= WSDOM.Element.parseSelector('ul li', flyout.getFrame());

	this.drawMenuOfExchanges = function() {
		return flyout;
	}

	this.getFlyoutLabelForExchanges = function() {
		return flyoutLabel;
	}

	this.getFlyoutControlsForExchanges = function() {
		return flyoutControls;
	}

	return this.drawMenuOfExchanges();
}

InvestorRelations.prototype.getActiveSymbol = function() { return ""; }
InvestorRelations.prototype.setActiveSymbol = function(s) {
	this.getActiveSymbol = function() {
		return s;
	}
}

InvestorRelations.prototype.position = function (e, el) {
    var contentWell = WSDOM.Element.getXY(this.getFrame().offsetParent);
	var iconSize = WSDOM.Element.getSize(el);
	
    var view = WSDOM.Element.getViewport();
	var frame = this.getFrame();

    var frameSize = WSDOM.Element.getSize(frame);

    var frameTop = view.top + e.nativeEvent.clientY;//Math.max(view.top + ( view.height / 2 ) - ( frameSize.height / 2 ), 0) - contentWell.y;
    var frameLeft = e.nativeEvent.clientX + iconSize.width;//Math.max(( view.width / 2 ) - ( frameSize.width / 2 ), 0) - contentWell.x;

    WSDOM.Element.setXY(frame, frameLeft, frameTop);
	this.sizeShim();
	// add a class instead
    frame.style.visibility = 'visible';
};

InvestorRelations.prototype.close = function (e, el) {
	this.setActiveSymbol("");

	if(e){ e.cancel() };

	var frame = this.getFrame();
	
	if (!frame) {
		return;
	}
	
    WSDOM.Element.addClass(frame, this.CSS_HIDDEN);
	frame.style.visibility = "hidden";
};

// this is a non-dragable module
InvestorRelations.prototype.dragStart = function() {
	return false;
}

InvestorRelations.prototype.getCloseLink = function () {
	var closeEvent = this.getCloseEvent();
	var closeLink = Element.create('a', { href: '#', className: 'closeLink' }, '&nbsp;'); 
	
	closeEvent.addElement(closeLink);
	this.getCloseLink = function() {
		
		return closeLink;
	
	};

	return this.getCloseLink();
};

InvestorRelations.prototype.drawPopup = function(e, el) {
	var symbol = el.getAttribute("ftStandard");
	var widgets = [];
	//for (var i = 0, isActive; i < this.WIDGET_TYPES.length; i++) {
	var isActive;
	for (var i in this.WIDGET_TYPES) {
		isActive = Number(el.getAttribute(this.WIDGET_TYPES[i].key));
		
		if (isActive) {
			widgets.push(
				WSDOM.Element.create("li", {"class":"contain"}, [
					WSDOM.Element.create("a", {"href":"/ft/tearsheets/performance.asp?s="+symbol+"&widgets=1", "class":this.CSS_WIDGET + " " + this.WIDGET_TYPES[i].css}, this.WIDGET_TYPES[i].name)
				])
			);
		}
	}
	
	this.setTitleText(this.POPUP_TITLE);
	
	if (symbol == this.getActiveSymbol()) {
		this.getCloseEvent().fire();
		
		this.setActiveSymbol("");
	} else {
		this.clearContent();
		this.getCloseEvent().fire();
		
		this.setActiveSymbol(symbol);
		
		WSDOM.Element.create("div", null, [
			WSDOM.Element.create("ul", {}, widgets)
		], this.getContent());
		
		WSDOM.Element.addClass(this.getFrame(), "investorRelationsPopup");
		
		if (this.isVisible()) {
			return;
		}

		if (!this.allowOthers() && Popup.instances) {
			for( var i = 0; i < Popup.instances.length; i++ )
			{
				Popup.instances[i].close();
			}
		}

		var frame = this.getFrame();
		WSDOM.Element.removeClass(frame, this.CSS_HIDDEN);

		this.position(e, el);
		
		this.sizeShim();
	}
}

InvestorRelations.prototype.draw = function() {
	this.drawMenuOfCountries();
	this.drawMenuOfExchanges();
	this.drawMenuOfLetters();
}